home *** CD-ROM | disk | FTP | other *** search
/ Skunkware 5 / Skunkware 5.iso / src / X11 / xarchie-2.0.9 / display-x.c < prev    next >
Encoding:
C/C++ Source or Header  |  1995-06-19  |  8.7 KB  |  432 lines
  1. /*
  2.  * display-x.c : Display routines for xarchie
  3.  *
  4.  * George Ferguson, ferguson@cs.rochester.edu, 23 Apr 1993.
  5.  * 14 May 1993: Need <stdio.h> when DEBUG defined.
  6.  *        Need to resize List in redrawBrowserPane() when MULTILIST
  7.  *        not defined. 
  8.  */
  9.  
  10. #include <stdio.h>
  11. #include <X11/Intrinsic.h>
  12. #include <X11/StringDefs.h>
  13. #include <X11/Xaw/AsciiText.h>
  14. #ifdef MULTILIST
  15. #include <MultiList.h>
  16. #else
  17. #include <X11/Xaw/List.h>
  18. #endif
  19. #include "xarchie.h"
  20. #include "appres.h"
  21. #include "browser.h"
  22. #include "alert.h"
  23. #include "xutil.h"
  24. #include "stringdefs.h"            /* bezro, bcopy */
  25. #include "debug.h"
  26.  
  27. /*
  28.  * Functions defined here:
  29.  */
  30. /* Text output routines */
  31. void setTitleText(), setStatusText();
  32. void setSearchText(), setHostText(), setLocationText(), setFileText();
  33. void setSizeText(), setModesText(), setDateText();
  34.  
  35. /* Button sensitivity routines */
  36. void setQuerySensitive(), setAbortSensitive();
  37. void setUpSensitive(), setDownSensitive();
  38.  
  39. /* Browser routines */
  40. void initBrowser(),clearBrowser(),redrawBrowser();
  41. void clearBrowserPane(), redrawBrowserPane(), unhighlightBrowserPane();
  42. void clearBrowserItem(), redrawBrowserItem(), unhighlightBrowserItem();
  43. void highlightBrowserItem(), setBrowserItem();
  44. /* Browser action routines */
  45. void nextBrowserPane(),prevBrowserPane();
  46. void nextBrowserItem(),prevBrowserItem();
  47. void toggleCurrentBrowserItem(),selectCurrentBrowserItem();
  48.  
  49. /* Misc. display routines */
  50. void beep();
  51.  
  52. /* Internal routines */
  53. static void updatePasteBuffer(), setListString();
  54.  
  55. /*
  56.  * Data defined here:
  57.  */
  58. /*
  59.  * These string arrays are needed since the only way to set a List
  60.  * widget in X is to pass it an array of strings. That is, there's
  61.  * no way to add items incrementally. Blech. Still, the arrays are
  62.  * grown as needed, so these values can be way off, as they are.
  63.  */
  64. #define INIT_NUM_BROWSER_STRINGS 1
  65. #define REALLOC_INCR(num) (2*(num))
  66.  
  67. static char **browserStrings[NUM_BROWSER_PANES];
  68. static int numBrowserStrings[NUM_BROWSER_PANES];
  69.  
  70. /*    -    -    -    -    -    -    -    -    */
  71. /* Text output */
  72.  
  73. /*ARGSUSED*/
  74. void
  75. setTitleText(str)
  76. char *str;
  77. {
  78.     /*EMPTY*/
  79. }
  80.  
  81. void
  82. setStatusText(str)
  83. char *str;
  84. {
  85.     setWidgetString(statusText,str);
  86.     XFlush(display);
  87. }
  88.  
  89. void
  90. setSearchText(str)
  91. char *str;
  92. {
  93.     setWidgetString(searchText,str);
  94. }
  95.  
  96. void
  97. setHostText(str)
  98. char *str;
  99. {
  100.     setWidgetString(hostText,str);
  101.     if (appResources.pasteBuffer)
  102.     updatePasteBuffer();
  103. }
  104.  
  105. void
  106. setLocationText(str)
  107. char *str;
  108. {
  109.     setWidgetString(locationText,str);
  110.     if (appResources.pasteBuffer)
  111.     updatePasteBuffer();
  112. }
  113.  
  114. void
  115. setFileText(str)
  116. char *str;
  117. {
  118.     setWidgetString(fileText,str);
  119.     if (appResources.pasteBuffer)
  120.     updatePasteBuffer();
  121. }
  122.  
  123. void
  124. setSizeText(str)
  125. char *str;
  126. {
  127.     setWidgetString(sizeText,str);
  128. }
  129.  
  130. void
  131. setModesText(str)
  132. char *str;
  133. {
  134.     setWidgetString(modesText,str);
  135. }
  136.  
  137. void
  138. setDateText(str)
  139. char *str;
  140. {
  141.     setWidgetString(dateText,str);
  142. }
  143.  
  144. static void
  145. updatePasteBuffer()
  146. {
  147.     char *host,*loc,*file,*buf;
  148.  
  149.     host = getWidgetString(hostText);
  150.     loc = getWidgetString(locationText);
  151.     file = getWidgetString(fileText);
  152.     buf = XtMalloc(strlen(host)+strlen(loc)+strlen(file)+3);
  153.     sprintf(buf,"%s:%s/%s",host,loc,file);
  154.     XStoreBytes(display,buf,strlen(buf));
  155.     XtFree(buf);
  156. }
  157.  
  158. /*    -    -    -    -    -    -    -    -    */
  159. /* Buttons */
  160.  
  161. void
  162. setQuerySensitive(state)
  163. int state;
  164. {
  165.     int i;
  166.  
  167.     XtSetSensitive(queryButton,(state > 0 ? True : False));
  168.     /* Disable the Lists so they get redrawn in "gray" */
  169.     for (i=0; i < NUM_BROWSER_PANES; i++)
  170.     XtSetSensitive(browserLists[i],(state > 0 ? True : False));
  171.     /* This is a simple way to disable the up/down buttons */
  172.     XtSetSensitive(browserForm,(state > 0 ? True : False));
  173.     /* Update the icon also (True=busy, when query off ie. state = 0) */
  174.     setIconStatus((state > 0) ? False : True);
  175. }
  176.  
  177. void
  178. setAbortSensitive(state)
  179. int state;
  180. {
  181.     XtSetSensitive(abortButton,(state > 0 ? True : False));
  182. }
  183.  
  184. void
  185. setUpSensitive(state)
  186. int state;
  187. {
  188.     XtSetSensitive(browserUpButton,(state > 0 ? True : False));
  189. }
  190.  
  191. void
  192. setDownSensitive(state)
  193. int state;
  194. {
  195.     XtSetSensitive(browserDownButton,(state > 0 ? True : False));
  196. }
  197.  
  198. /*    -    -    -    -    -    -    -    -    */
  199. /* Browser */
  200.  
  201. void
  202. initBrowser()
  203. {
  204.     /*EMPTY*//* Done by widget creation */
  205. }
  206.  
  207. void
  208. clearBrowser()
  209. {
  210.     int pane;
  211.  
  212.     for (pane=0; pane < NUM_BROWSER_PANES; pane++) {
  213.     clearBrowserPane(pane);
  214.     }
  215. }
  216.  
  217. void
  218. redrawBrowser()
  219. {
  220.     /*EMPTY*/
  221. }
  222.  
  223. /* Browser panes */
  224.  
  225. void
  226. clearBrowserPane(pane)
  227. int pane;
  228. {
  229.     static char *emptyNames[] = { NULL };
  230.  
  231. #ifdef MULTILIST
  232.     XfwfMultiListSetNewData((XfwfMultiListWidget)browserLists[pane],
  233.                 emptyNames,0,0,False,(Boolean *)NULL);
  234. #else
  235.     XawListChange(browserLists[pane],emptyNames,0,0,False);
  236. #endif
  237. }
  238.  
  239. void
  240. redrawBrowserPane(pane)
  241. int pane;
  242. {
  243. #ifdef MULTILIST
  244.     XfwfMultiListSetNewData((XfwfMultiListWidget)browserLists[pane],
  245.                 browserStrings[pane],0,0,True,(Boolean *)NULL);
  246. #else
  247.     XawListChange(browserLists[pane],browserStrings[pane],0,0,True);
  248. #endif
  249. }
  250.  
  251. void
  252. unhighlightBrowserPane(pane)
  253. int pane;
  254. {
  255. #ifdef MULTILIST
  256.     XfwfMultiListUnhighlightAll((XfwfMultiListWidget)browserLists[pane]);
  257. #else
  258.     XawListUnhighlight(browserLists[pane]);
  259. #endif
  260. }
  261.  
  262. /* Browser items */
  263.  
  264. /*ARGSUSED*/
  265. void
  266. clearBrowserItem(pane,item)
  267. int pane,item;
  268. {
  269.     /*EMPTY*/
  270. }
  271.  
  272. /*ARGSUSED*/
  273. void
  274. redrawBrowserItem(pane,item)
  275. int pane,item;
  276. {
  277.     /*EMPTY*/
  278. }
  279.  
  280. void
  281. unhighlightBrowserItem(pane,item)
  282. int pane,item;
  283. {
  284. #ifdef MULTILIST
  285.     XfwfMultiListUnhighlightItem((XfwfMultiListWidget)browserLists[pane],item);
  286. #else
  287.     XawListUnhighlight(browserLists[pane]);
  288. #endif
  289. }
  290.  
  291. void
  292. highlightBrowserItem(pane,item)
  293. int pane,item;
  294. {
  295.     Arg args[1];
  296.     int number;
  297.     float percent;
  298.  
  299. #ifdef MULTILIST
  300.     XfwfMultiListHighlightItem((XfwfMultiListWidget)browserLists[pane],item);
  301. #else
  302.     XawListHighlight(browserLists[pane],item);
  303. #endif
  304.     /* Move the scrollbar so we see the item */
  305.     if (appResources.autoScroll) {
  306.     XtSetArg(args[0],XtNnumberStrings,&number);
  307.     XtGetValues(browserLists[pane],args,1);
  308.     percent = (float)(item-1) / (float)number;
  309.     if (percent < 0.0)
  310.         percent = 0.0;
  311.     else if (percent > 100.)
  312.         percent = 100.0;
  313.     XtCallCallbacks(browserScrollbars[pane],
  314.             "jumpProc",(XtPointer)&percent);
  315.     }
  316. }
  317.  
  318. void
  319. setBrowserItem(pane,item,str)
  320. int pane,item;
  321. char *str;
  322. {
  323.     /* Set the actual value */
  324.     setListString(pane,item,str);
  325.     /* Need a terminating NULL later, so add it now */
  326.     setListString(pane,item+1,NULL);
  327. }
  328.  
  329. /* Browser actions */
  330.  
  331. void
  332. nextBrowserPane()
  333. {
  334.     /*EMPTY*//* Done with mouse */
  335. }
  336.  
  337. void
  338. prevBrowserPane()
  339. {
  340.     /*EMPTY*//* Done with mouse */
  341. }
  342.  
  343. void
  344. nextBrowserItem()
  345. {
  346.     /*EMPTY*//* Done with mouse */
  347. }
  348.  
  349. void
  350. prevBrowserItem()
  351. {
  352.     /*EMPTY*//* Done with mouse */
  353. }
  354.  
  355. void
  356. toggleCurrentBrowserItem()
  357. {
  358.     /*EMPTY*//* Done by X */
  359. }
  360.  
  361. void
  362. selectCurrentBrowserItem()
  363. {
  364.     /*EMPTY*//* Done by X */
  365. }
  366.  
  367. /*    -    -    -    -    -    -    -    -    */
  368. /* Misc. display routines */
  369.  
  370. void
  371. beep()
  372. {
  373.     XBell(display,0);
  374. }
  375.  
  376. /*    -    -    -    -    -    -    -    -    */
  377. /*
  378.  * setListString() : This routine provides access to the dynamically-grown
  379.  *    lists of strings. I bzero() the allocated space even though I shouldn't
  380.  *    need to.
  381.  */
  382. static void
  383. setListString(pane,index,string)
  384. int pane,index;
  385. char *string;
  386. {
  387.     char **oldStr;
  388.     int oldNum;
  389.  
  390.     DEBUG3("setting index %d of pane %d to \"%s\"\n",index,pane,string);
  391.     if (pane >= NUM_BROWSER_PANES) {
  392.     alert2("Attempt to set string in pane %d: \"%s\"",(char *)pane,string);
  393.     return;
  394.     }
  395.     /* Free old string if there was one */
  396.     if (index < numBrowserStrings[pane]) {
  397.     XtFree((XtPointer)(*(browserStrings[pane]+index)));
  398.     DEBUG0("  freed old string\n");
  399.     }
  400.     /* If this is the first call, get the initial string array */
  401.     if (numBrowserStrings[pane] == 0) {
  402.     DEBUG0("  getting initial string array\n");
  403.     numBrowserStrings[pane] = INIT_NUM_BROWSER_STRINGS;
  404.     browserStrings[pane] = (char **)XtCalloc(numBrowserStrings[pane],
  405.                          sizeof(char *));
  406.     bzero((char *)(browserStrings[pane]),
  407.           numBrowserStrings[pane]*sizeof(char *));
  408.     }
  409.     DEBUG1("  string array is size %d\n",numBrowserStrings[pane]);
  410.     /* Grow the array until it's big enough for this string */
  411.     while (index >= numBrowserStrings[pane]) {
  412.     DEBUG0("  growing string array\n");
  413.     oldStr = browserStrings[pane];
  414.     oldNum = numBrowserStrings[pane];
  415.     numBrowserStrings[pane] = REALLOC_INCR(numBrowserStrings[pane]);
  416.     browserStrings[pane] = (char **)XtCalloc(numBrowserStrings[pane],
  417.                          sizeof(char *));
  418.     bzero((char *)(browserStrings[pane]),
  419.           numBrowserStrings[pane]*sizeof(char *));
  420.     bcopy((char *)oldStr,(char *)(browserStrings[pane]),
  421.           oldNum*sizeof(char *));
  422.     XtFree((XtPointer)oldStr);
  423.     }
  424.     DEBUG1("  string array is now size %d\n",numBrowserStrings[pane]);
  425.     /* Finally, set this value */
  426.     if (string == (char *)NULL)
  427.     *(browserStrings[pane]+index) = (char *)NULL;
  428.     else
  429.     *(browserStrings[pane]+index) = XtNewString(string);
  430.     DEBUG1("  done setting string \"%s\"\n",string);
  431. }
  432.